package String1;

import java.util.Arrays;

public class String2 {
    public static boolean equals(String s,String s1){
        if(s.length()==s1.length()){
            for(int i=0;i<s.length();i++){
                if(s.charAt(i)==s1.charAt(i)){
                    return true;
                }
            }
        }
        return false;
    }
     public int m =314;
    public String2(int k){
        this.m=k;
    }

    public int getM() {
        return m;
    }

    @Override
    public String toString() {
        return "String2{" +
                "m=" + m +
                '}';
    }

    public static void main(String[] args){
        //认识String类，定义String类型变量有三种办法如下：
        String s="happy";
        String s1=new String("happy");
        char[] ay={'a','b','c','d','f'};
        String S2=new String(ay);//使用字符数组构造
        String s3=s1;//指把s1变量引用地址内容赋给s3变量，两个变量存相同的地址
        //求字符串对象的长度
        int a=s.length();
        System.out.println("长度为"+a);
        //比较字符串
        boolean b=(s==s1);//==比较的是字符串变量的地址
        System.out.println("比较完s1与s2地址了，结果为："+b);
        boolean c=s.equals(s1);//其原本内部也是用==比较但可以重写比较方法比较变量所指向对象的内容
        System.out.println("比较的是内容（先检查长度是否相等，相等开始比较每个字符）返回值为:"+c);
        //compareTo比较字符串大小返回的是两字符串差值大小，有大小写区分
        int  d= s.compareTo(s1);
        System.out.println("两者差值为"+d);
        //用compareToIgnoreCase比较两字符串码值，不区分大小写
        int o=s.compareToIgnoreCase(s1);
        System.out.println("俩字符串差值："+o);
        //根据对应下标查找对应字符
        String s4="life";
        char w=s4.charAt(2);
        System.out.println("下标为2的对应字符为"+w);
        //求数组长度
        char[] h={'w','f','l','o','v','e'};
        System.out.println("数组长度"+h.length);
        //据对应字符找到其在字符串的下标与以下的重载行为
        int index=s4.indexOf('i');
        System.out.println("l下标为"+index);
        //指定下标开始找字符
        int index2=s4.indexOf('f',1);
        System.out.println("根据指定下标开始找到的f的字符为"+index2);
        //在字符串中找对应小块字符串返回第一次找到的位置的起始下标
        int index3=s4.indexOf("fe");
        System.out.println("在s4字符串找到fe字符串的下标为："+index3);
        //从后往前找字符并返回对应下标，还有以下的一些重载方法
        int index4=s4.lastIndexOf('i');
        System.out.println("i的对应下标为"+index4);
        //从指定下标的位置开始从后往前找，并返回下标,找不到返回-1
        int index5=s4.lastIndexOf('i',3);
        System.out.println("i下标为"+index5);
        //从指定下标往前找字符串，返回第一个找到的字符串的起始下标
        int index6=s4.lastIndexOf("li",3);
        System.out.println("字符串li的下标为"+index6);
        //转化1.数值转化为字符串 2.字符串转化为数值
        String s5=String.valueOf(1234);
        System.out.println("数值转换为字符串为"+s5);
        String2 in=new String2(3000);
        String s7=String.valueOf(in);//对象变成字符串叫序列化
        String s6=String.valueOf(new String2(400));
        System.out.println("新建对象转换为字符串为"+s6);//记得重写toString方法
        System.out.println("新建对象转换为字符串为"+s7);
        //把字符串转化为对应数值（包装类.pase+类型首字母大写）
        int t=Integer.parseInt("789");
        double p=Double.parseDouble("3.14");
        System.out.println("789字符串转换为数值为"+t);
        System.out.println("3.14字符串转换为双精度浮点数数值为"+p);
        //大小写转换1.小写转大写2.大写转小写
        String s9="happy";
        String s0=s9.toUpperCase();
        System.out.println("s9小写转大写为"+s0);
        String se="HEALTH";
        String se2=se.toLowerCase();
        System.out.println("大写转小写为"+se2);
        /*只要是涉及到String类型字符的转变，都不是在原有字符串上进行的，会生成新对象原因并不是String类有final【只是代表不可以被继承】
        也不是String类中值被final修饰而是String类中value值被private修饰，不可被访问，故修改都是创一个新对象*/
        //字符串变为数组：
        String e="hello";
        char[] array=e.toCharArray();
        System.out.println("字符串转为数组为"+ Arrays.toString(array));
        //数组转字符串
        char[] ch={'c','a','k','e'};
        String ch2=new String(ch);//直接新建对象传入参数
        System.out.println("ch数组转化为字符串为"+ch2);
        //格式化
        int n1=2025;
        int n2=8;
        int n3=7;
        String n=String.format("%d-%d-%d",n1,n2,n3);
        System.out.println("格式化后"+n);
        //字符串的替换方法及以下重载方法
        String s10="llovell";
        String s11=s10.replace('o','v');//把含o的都改成v
        System.out.println("改后的字符串为"+s11);
        String s12=s10.replace("ve","oo");
        System.out.println("改后字符串："+s12);
        //把识别到的第一个字符串换为对应字符串
        String s13=s10.replaceFirst("ll","ee");
        System.out.println("替换后的第一个字符为："+s13);
        //把所有的xxx字符串替换为对应字符串
        String s14=s10.replaceAll("ll","haha");
        System.out.println("把ll替换为haha字符为："+s14);
        //字符串的拆分，拆出字符串数组元素
        String s17="name=coco&age=18";
        String[] s18=s17.split("&");//字符串数组打印方式与普通数组相同
        System.out.println(Arrays.toString(s18));
        //若选择多个作为分隔符可以用|进行分割
        String[]  s19=s17.split("&|=");
        System.out.println("被&与=分隔后的字符数组为"+Arrays.toString(s19));
        //注意如果分隔符是"|","*","+"," ."都要加上转义字符“\\”,若是“\”那么的写成“\\\\”

        //字符串的截取，用Sring对象方法Substring
        String s20="happy new year";
        String s21=s20.substring(2);//从下标2开始截取
        System.out.println("从下标2开始截取s20得到的字符串为"+s21);
        //控制截取范围
        String s22=s20.substring(2,4);
        System.out.println("控制截取下标范围为2-4截取出的字符串为："+s22);
        //String对象的去掉首尾空格的方法trim()
        String s23="   pop   you  ";
        String s24=s23.trim();
        System.out.println("去掉首尾空格后字符串为"+s24);
        //final修饰数组时数组名只可存原来的地址，不可被修改
        /*修改1.用“+”拼接 2.StringBuilder或StringBuffer创建对象（与String类对象不同，其字符串可以修改
        且不会像String类字符串修改会产生很多新对象）的append方法*/
        StringBuffer s25=new StringBuffer("popsing");
       StringBuffer s26= s25.append("author");
        System.out.println("添加后的语句:"+s26.toString());//toStrign把StringBuffer类型转为String类型
        StringBuilder s27=new StringBuilder("hard");
        StringBuilder s28=s27.append("work");
        System.out.println("添加后的语句："+s28.toString());//toStrign把StringBuilder类型转为String类型
        //计算从1970年到现在的毫秒数的时间
        long ww=System.currentTimeMillis();
        System.out.println(ww);
        //StringBuilder对象方法逆置字符串reverse()
        StringBuilder s29=new StringBuilder("ABCDH");
        System.out.println("逆置后的字符串"+s29.reverse());
        //StringBuilder对象方法插入字符串insert()
        StringBuilder s30=s29.insert(2,"haha");//在下标为3的位置用haha插入
        System.out.println("插入后的字符串为："+s30);
        //StringBuilder对象方法删除字符串delete()，左闭右开
        StringBuilder s32=new StringBuilder("ghhjjkkkkk");
        StringBuilder s31=s32.delete(2,6);
        System.out.println("删除后的字符串为:"+s31);
        //s.toString()方法必然返回新对象，StringBuffer一般用于多线程情况，保证线程安全，
        // StringBuilder一般用于单线程情况，String与StringBuilder类不能直接转换要想互相转换，利用StringBuilder的构造方法或append()方法
        //StringBuilder变为String类可调用toString（）方法
        /*String、StringBuffer、StringBuilder区别
        1.String内容不可修改，StringBuilder与StringBuffer内容可以修改
        2.StringBuffer与StringBuilder大部分功能相似
        3.StringBuffer采用同步处理，属于线程安全操作而StringBuilder未采用同步处理，属于线程不安全的操作
         */
    }
}
